package ltd.simulatoruidemo.util;

import android.content.Context;
import android.os.Environment;
import android.util.Log;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import static android.os.Environment.DIRECTORY_DOWNLOADS;
import static android.os.Environment.getExternalStoragePublicDirectory;

public final class StorageUtil {
    private static final String TAG = "StorageUtil" ;
//	private static final Logger LOGGER = org.slf4j.LoggerFactory.getLogger(StorageUtil.class);

//	 private static boolean Debug_mode=false;
//
//	 static String[] SDTAL={"EXTERNAL_STORAGE","SECONDARY_STORAGE",};
//	 public static int storageNum=0;
//	 public static int storageID=0;
//     public StorageUtil()
//     {
//     }
//     public static class StoragePathInfo{
//    	 public String path =null;
//    	 public int    state=0;//0:可读可写 1：不可写 2：没有权限
//    	 public StoragePathInfo(String path,int state)
//    	 {
//    		 this.path=path;
//    		 this.state=state;
//    	 }
//     }
//     /**
//      *
//      * @param name 检测是否存在用到的文件路径
//      * @return     返回可以用的路径(检测用的路径不存在时返回默认内置卡路径)
//      */
//     public static String GetCurrentStorageDir(String name)
//     {
//    	 return find_local_sd_path(name);
//     }
//     public static String GetCurrentStorageDir(String[] name)
//     {
//    	 return find_local_sd_path(name);
//     }
//     /**
//      *
//      * @param name 要判断的文件路径
//      * @return     返回可以用的路径(检测用的路径不存在时返回默认内置卡路径)
//      */
// 	 static String find_local_sd_path(String name)
// 	 {
// 		String DefaultPath=Environment.getExternalStorageDirectory().getAbsolutePath();
// 		File dir=null;
// 		String[] columns;
// 		String PATH = getMyStorageDirectory_new(DefaultPath);
// 		if(Define.isEmptyByString(PATH) != null)
// 		{
// 			columns = PATH.split("\n");
// 	 		for(int i=0; i<columns.length; i++){
// 	 			dir = new File(columns[i]+"/"+name);
// 	 			if(dir.exists())
// 	 			{
// 	 				if(!DefaultPath.equalsIgnoreCase(columns[i])) //忽略大小写的比较
// 	 				{
// 	 					if(checkRW(columns[i]))
// 	 					{
// 	 						storageNum=1;
// 	 	 					return columns[i];
// 	 					}
// 	 				}
// 	 		    }
// 	 		}
// 		}
// 		storageNum=0;
// 		return DefaultPath;
// 	 }
// 	 void t(String name)
// 	 {
// 		List<String> pathList = new ArrayList<String>();
//    	pathList=getExtSDCardPathList(pathList);
// 	 }
// 	static String find_local_sd_path(String[] name)
//	 {
//		String DefaultPath=Environment.getExternalStorageDirectory().getAbsolutePath();
//		File dir=null;
//		String[] columns;
//		String PATH = getMyStorageDirectory_new(DefaultPath);
//		if(Define.isEmptyByString(PATH) != null)
//		{
//			columns = PATH.split("\n");
//			for(int j=0; j<name.length; j++)
//			{
//				for(int i=0; i<columns.length; i++){
//					dir = new File(columns[i]+"/"+name[j]);
//					if(dir.exists())
//					{
//						if(!DefaultPath.equalsIgnoreCase(columns[i])) //忽略大小写的比较
//						{
//							if(checkRW(columns[i]))
//							{
//								storageNum=1;
//								return columns[i];
//							}
//						}
//				    }
//				}
//			}
//		}
//		storageNum=0;
//		return DefaultPath;
//	 }
// 	 public static String getDefaultPath()
// 	 {
// 		 return Environment.getExternalStorageDirectory().getAbsolutePath();
// 	 }
//     /**
//      * 获取扩展存储路径，TF卡、U盘
//      * dir:返回后用\n分割
//      */
//     public static String getMyStorageDirectory(){
//         String dir = new String();
//         try {
//             Runtime runtime = Runtime.getRuntime();
//             Process proc = runtime.exec("mount");
//             InputStream is = proc.getInputStream();
//             InputStreamReader isr = new InputStreamReader(is);
//             String line;
//             BufferedReader br = new BufferedReader(isr);
//             while ((line = br.readLine()) != null) {
//                 if (line.contains("secure")) continue;
//                 if (line.contains("asec")) continue;
//
//                 if (line.contains("fat")) {
//                     String columns[] = line.split(" ");
//                     if (columns != null && columns.length > 1) {
//                         dir = dir.concat(columns[1] + "\n");
//                     }
//                 } else if (line.contains("fuse")) {
//                     String columns[] = line.split(" ");
//                     if (columns != null && columns.length > 1) {
//                         dir = dir.concat(columns[1] + "\n");
//                     }
//                 }
//             }
//         } catch (Exception e) {
//             // TODO Auto-generated catch block
//             e.printStackTrace();
//         }
//         return dir;
//     }

	/**
	 * 搜索外置sd卡、TF卡路径
	 * @param innerSdPath 内置SD卡的路径
	 * @return
	 */
	private static List<String> getExtSDCardPathList(String innerSdPath){
//         String dir = new String();
		 List<String> sdPathsList = new ArrayList<>();
         try {
             // obtain executed result of command line code of 'mount', to judge
             // whether tfCard exists by the result
             Runtime runtime = Runtime.getRuntime();
             Process process = runtime.exec("mount");
             InputStream is = process.getInputStream();
             InputStreamReader isr = new InputStreamReader(is);
             BufferedReader br = new BufferedReader(isr);
             String line = null;
             int mountPathIndex = 1;

             while ((line = br.readLine()) != null)
             {
                 // format of sdcard file system: vfat/fuse
                 if ((!line.contains("fat") && !line.contains("fuse") && !line
                         .contains("storage"))
                         || line.contains("secure")
                         || line.contains("asec")
                         || line.contains("firmware")
                         || line.contains("shell")
                         || line.contains("private")
                         || line.contains("obb")
                         || line.contains("legacy") || line.contains("data")

                         || line.contains("tmpfs")
                		 || line.contains("bootloader")
                		 ) {
                     continue;
                 }
                 String[] parts = line.split(" ");
                 int length = parts.length;
                 if (mountPathIndex >= length) {
                     continue;
                 }
                 String mountPath = parts[mountPathIndex];
                 if (!mountPath.contains("/") || mountPath.contains("data")
                         || mountPath.contains("Data")) {
                     continue;
                 }
                 File mountRoot = new File(mountPath);

                 if (!mountRoot.exists() || !mountRoot.isDirectory()) {
                     continue;
                 }
                 if (!mountRoot.canWrite()) {
                     continue;
                 }
                 boolean equalsToPrimarySD = mountPath.equals(innerSdPath);
                 if (equalsToPrimarySD) {
                     continue;
                 }

				//判断是否已有
                 if (CollectionUtil.isNotEmpty(sdPathsList)){
					 boolean bFlag=false;
					 for (String path : sdPathsList){
						 if(mountPath.equalsIgnoreCase(path)) //忽略大小写的比较
						 {
							 bFlag=true;
							 break;
						 }
					 }
					 if (bFlag){
						 continue;
					 }
				 }
				 //不可读写返回
				 if (!checkRW(mountPath)){
					 continue;
				 }
				 //加上 扩展存储卡即TF卡或者SD卡路径
				 sdPathsList.add(mountPath);
//                 String[] columns;
//         		 String PATH = dir;
//         		 if(StringUtil.isNotEmpty(PATH))
//         		 {
//         			columns = PATH.split("\n");
//         			boolean bFlag=false;
//         			for(int i=0; i<columns.length; i++)
//         			{
//         				if(mountPath.equalsIgnoreCase(columns[i])) //忽略大小写的比较
// 						{
// 							bFlag=true;
// 						}
//     				}
//         			if(bFlag)
//         				continue;
//         		 }
//                 扩展存储卡即TF卡或者SD卡路径
//                 dir = dir.concat(mountPath + "\n");
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
		 return sdPathsList;
//         return dir;
     }
//     /**
//      *
//      * @return   返回可用的sd卡路径list
//      */
//     public static ArrayList<String> GetStoragePathList(ArrayList<String> StoragedirPathList,String currentPath,String path)
//     {
//    	List<String> pathList = new ArrayList<String>();
//    	pathList=getExtSDCardPathList(pathList);
//
//  		if(StoragedirPathList == null)
//  		   StoragedirPathList= new ArrayList<String>();
//  		StoragedirPathList.removeAll(StoragedirPathList);
//  		StoragedirPathList.clear();
//  		StoragedirPathList.add(currentPath);
//  		for(int i=0;i<pathList.size();i++)
//  		{
//  			if(!currentPath.equalsIgnoreCase(pathList.get(i)))
//  				StoragedirPathList.add(pathList.get(i));
//  		}
//  		pathList.removeAll(pathList);
//  		pathList.clear();
//  		pathList=null;
//  		return StoragedirPathList;
//     }
//     /**
//      * SD卡是否存在
//      * @return
//      */
//     private boolean ExistSDCard() {
//    	  if (Environment.getExternalStorageState().equals(
//    	    Environment.MEDIA_MOUNTED)) {
//
//    		    try {
//
//    		        // 获取扩展存储设备的文件目录
//    		        File SDFile = Environment
//    		                .getExternalStorageDirectory();
//
//    		        // 打开文件
//    		        File myFile = new File(SDFile.getAbsolutePath()
//    		                + File.separator + "MyFile.txt");
//
//    		        // 判断是否存在,不存在则创建
//    		        if (!myFile.exists()) {
//    		            myFile.createNewFile();
//    		        }
//
//    		        // 写数据
//    		        String szOutText = "Hello, World!";
//    		        FileOutputStream outputStream = new FileOutputStream(myFile);
//    		        outputStream.write(szOutText.getBytes());
//    		        outputStream.close();
//
//    		    } catch (Exception e) {
//    		        // TODO: handle exception
//    		    }// end of try
//    		return true;
//    	  }else if(Environment.getExternalStorageState().endsWith(Environment.MEDIA_MOUNTED_READ_ONLY)){
//    		   // 获取扩展存储设备的文件目录
//    		    File SDFile = Environment.getExternalStorageDirectory();
//
//    		    // 创建一个文件
//    		    File myFile = new File(SDFile.getAbsolutePath() + File.separator
//    		            + "MyFile.txt");
//
//    		    // 判断文件是否存在
//    		    if (myFile.exists()) {
//    		        try {
//
//    		            // 读数据
//    		            FileInputStream inputStream = new FileInputStream(myFile);
//    		            byte[] buffer = new byte[1024];
//    		            inputStream.read(buffer);
//    		            inputStream.close();
//
//    		        } catch (Exception e) {
//    		            // TODO: handle exception
//    		        }// end of try
//    		    }// end of if(myFile)
//    		    return true;
//    	  }
//    	   else
//    	   return false;
//    	 }
//     public static long _getSDFreeSize(){
//    	//取得SD卡文件路径
//         File path = Environment.getExternalStorageDirectory();
//         StatFs sf = new StatFs(path.getPath());
//         //获取单个数据块的大小(Byte)
//         long blockSize = sf.getBlockSize();
//         //空闲的数据块的数量
//         long freeBlocks = sf.getAvailableBlocks();
//         return freeBlocks * blockSize;  //单位Byte
//     }
//     public static long _getCourrentSDFreeSize(String storagedir){
//     	//取得SD卡文件路径
//          //File path = Environment.getExternalStorageDirectory();
//          File path = new File(storagedir);
//          StatFs sf = new StatFs(path.getPath());
//          //获取单个数据块的大小(Byte)
//          long blockSize = sf.getBlockSize();
//          //空闲的数据块的数量
//          long freeBlocks = sf.getAvailableBlocks();
//          return freeBlocks * blockSize;  //单位Byte
//      }
//     /**
//      * SD卡剩余空间
//      */
//     public long getSDFreeSize(){
//         //取得SD卡文件路径
//         File path = Environment.getExternalStorageDirectory();
//         StatFs sf = new StatFs(path.getPath());
//         //获取单个数据块的大小(Byte)
//         long blockSize = sf.getBlockSize();
//         //空闲的数据块的数量
//         long freeBlocks = sf.getAvailableBlocks();
//         //返回SD卡空闲大小
//         //return freeBlocks * blockSize;  //单位Byte
//         //return (freeBlocks * blockSize)/1024;   //单位KB
//         return (freeBlocks * blockSize)/1024 /1024; //单位MB
//       }
//     public static long getSDFreeSizeByMB(File path)
//     {
//    	 StatFs sf = new StatFs(path.getPath());
//         //获取单个数据块的大小(Byte)
//         long blockSize = sf.getBlockSize();
//         //空闲的数据块的数量
//         long freeBlocks = sf.getAvailableBlocks();
//         //返回SD卡空闲大小
//         //return freeBlocks * blockSize;  //单位Byte
//         //return (freeBlocks * blockSize)/1024;   //单位KB
//         return (freeBlocks * blockSize)/1024 /1024; //单位MB
//     }
//     /**
//      * SD卡总容量
//      * @return
//      */
//     public long getSDAllSize(){
//         //取得SD卡文件路径
//         File path = Environment.getExternalStorageDirectory();
//         StatFs sf = new StatFs(path.getPath());
//         //获取单个数据块的大小(Byte)
//         long blockSize = sf.getBlockSize();
//         //获取所有数据块数
//         long allBlocks = sf.getBlockCount();
//         //返回SD卡大小
//         //return allBlocks * blockSize; //单位Byte
//         //return (allBlocks * blockSize)/1024; //单位KB
//         return (allBlocks * blockSize)/1024/1024; //单位MB
//       }
//     public static long getSDAllSizeByMB(File path){
//    	 StatFs sf = new StatFs(path.getPath());
//         //获取单个数据块的大小(Byte)
//         long blockSize = sf.getBlockSize();
//         //获取所有数据块数
//         long allBlocks = sf.getBlockCount();
//         //返回SD卡大小
//         //return allBlocks * blockSize; //单位Byte
//         //return (allBlocks * blockSize)/1024; //单位KB
//         return (allBlocks * blockSize)/1024/1024; //单位MB
//     }
//     public static String getStorageState(String path,int state)
//     {
//    	 File filePath = new File(path);
//    	 String temp="剩余:"+getSDFreeSizeByMB(filePath)+"MB"+"\n"+
//    	             "总共:"+getSDAllSizeByMB(filePath)+"MB";
//    	 switch(state)
//    	 {  //0:可读可写 1：不可写 2：没有权限
//    	    case 1:
//    	    	 temp="注意:经测试，发现此存储位置不能写入数据，不可做存储用";
//    	    	 break;
//    	    case 2:
//    	    	 temp="注意:经测试，发现此存储位置没有读写权限，不可做存储用";
//    	    	 break;
//    	 }
//    	 return temp;
//     }
//     public void printf(){
//    	 Log.d("",""+ExistSDCard());
//    	 Log.d("getSDAllSize","getSDAllSize："+getSDAllSize());
//    	 Log.d("getSDFreeSize","getSDFreeSize："+getSDFreeSize());
//     }
//     /**
//      * 检测是否有空间
//      * @param len
//      * @return
//      */
//     public static boolean checkFileSize(final Context context,Handler mHandler,String storagedir,long len)
//     {
//    	 long t_len=_getCourrentSDFreeSize(storagedir);
//    	 if(Debug_mode)
//    	 {
//    		 t_len=len-1;
//    	 }
//    	 if(t_len>=len)
//    		 return true;
//    	 else
//    	 {
//    		 if(context!=null)
//    		 {
//    			 String t_str="当前存储位置:"+Define.LocalSD+
//    					      "\n目前剩余空间:"+(t_len/(1024*1024)+1)+"M"+
//    					      "\n文件需要空间:"+(len/(1024*1024)+1)+"M"+
//    					      "\n请前往 \'"+MSharedPreferences.getTextbookManagerPageName(context)+"\' 处"+
//    		                  "\n清理无用或过期的文件，以便有足够可用的空间";
//    			 final CustomDialog.Builder alog = new CustomDialog.Builder(context)
//     		            .setTitle("存储空间不足提示")
//     		    		.setMessage(t_str)
//     		            .setPositiveButton("确定", new DialogInterface.OnClickListener() {
//     		                @Override
//     		                public void onClick(DialogInterface dialog, int which) {
//     		                    // TODO Auto-generated method stub
//     		                    dialog.dismiss();
////     		                    Intent intent = new Intent();
////  		                        intent.setClass(context,P014.class);
////  				                intent.putExtra("tile", "数据清除");
////  				                intent.putExtra("lastpage", 0x00);
////  				                intent.putExtra("backpage", 0);
////  			                    context.startActivity(intent);
////  	                            ((Activity)context).finish();
//     		                }
//     		            });
//        		 mHandler.post(new Runnable() {
//
//     				@Override
//     				public void run() {
//     					// TODO 自动生成的方法存根
//     					alog.show();
//     				    //Define.setDialogText(alog.getWindow().getDecorView());
//     				}
//     			});
//    		 }
//    		 return false;
//    	 }
//     }
//     public static ExtrMsg checkFileSize(Context context,String rootpath,String filepath,long len,ExtrMsg msg)
//     {
//    	 long t_len=_getCourrentSDFreeSize(filepath);
//    	 if(Debug_mode)
//    	 {
//    		 t_len=len-1;
//    	 }
//    	 if(t_len>=len)
//    	 {
//    		 msg.bArg=true;
//    		 return msg;
//    	 }
//    	 else
//    	 {
//    		 msg.prompt="存储空间不足提示:";
//    		 msg.msg="当前存储位置:"+rootpath+
//				      "\n目前剩余空间:"+(t_len/(1024*1024)+1)+"M"+
//				      "\n文件需要空间:"+(len/(1024*1024)+1)+"M"+
//				      "\n请前往 \'"+MSharedPreferences.getTextbookManagerPageName(context)+"\' 处"+
//	                  "\n清理无用或过期的文件，以便有足够可用的空间";
//    		 msg.bArg=false;
//    		 return msg;
//    	 }
//     }
//     public static boolean checkPackFileSize(final Context context,Handler mHandler,String localsrc)
//     {
//    	 long len=0;
//    	 if (localsrc.contains(".rar"))
//    	 {
//    		 len=getRarFileUnpackSize(new File(localsrc))*21/10;
//    	 }else if(localsrc.contains(".zip"))
//    	 {
//    		 try {
//    			 len=getZipFileUnpackSize(localsrc)*21/10;
//			} catch (FileNotFoundException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			} catch (ZipException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			} catch (IOException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			}
//    	 }
//
//    	 long t_len=_getCourrentSDFreeSize(Define.LocalSD);
//    	 if(Debug_mode)
//    	 {
//    		 t_len=len-1;
//    	 }
//    	 if(t_len>=len)
//    		 return true;
//    	 else
//    	 {
//    		 if(context!=null)
//    		 {
//    			 String t_str="当前存储位置:"+Define.LocalSD+
//    					      "\n目前剩余空间:"+(t_len/(1024*1024)+1)+"M"+
//    					      "\n解压需要空间:"+(len/(1024*1024)+1)+"M"+
//    					      "\n请前往 \'"+MSharedPreferences.getTextbookManagerPageName(context)+"\' 处"+
//    		                  "\n清理无用或过期的文件，以便有足够可用的空间";
//    			 final CustomDialog.Builder alog = new CustomDialog.Builder(context)
//     		            .setTitle("存储空间不足，文件包无法解压缩！")
//     		    		.setMessage(t_str)
//     		            .setPositiveButton("确定", new DialogInterface.OnClickListener() {
//     		                @Override
//     		                public void onClick(DialogInterface dialog, int which) {
//     		                    // TODO Auto-generated method stub
//     		                    dialog.dismiss();
//
////     		                    Intent intent = new Intent();
////   		                        intent.setClass(context,P014.class);
////   				                intent.putExtra("tile", "数据清除");
////   				                intent.putExtra("lastpage", 0x00);
////   				                intent.putExtra("backpage", 0);
////   			                    context.startActivity(intent);
////   	                            ((Activity)context).finish();
//     		                }
//     		            });
//        		 mHandler.post(new Runnable() {
//
//     				@Override
//     				public void run() {
//     					// TODO 自动生成的方法存根
//     					alog.show();
//     				    //Define.setDialogText(alog.getWindow().getDecorView());
//     				}
//     			});
//    		 }
//    		 return false;
//    	 }
//     }
//     public static ExtrMsg checkPackFileSize(Context context,String rootpath,String localsrc,int type,ExtrMsg msg)
//     {
//    	 long len=0;
//    	 if (type == 1)
//    	 {//.rar
//    		 len=getRarFileUnpackSize(new File(localsrc))*21/10;
//    	 }else if(type == 2)
//    	 {//.zip
//    		 try {
//    			 len=getZipFileUnpackSize(localsrc)*21/10;
//			} catch (FileNotFoundException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			} catch (ZipException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			} catch (IOException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			}
//    	 }
//
//    	 long t_len=_getCourrentSDFreeSize(rootpath);
//    	 if(Debug_mode)
//    	 {
//    		 t_len=len-1;
//    	 }
//    	 if(t_len>=len)
//    	 {
//    		 msg.bArg=true;
//    		 return msg;
//    	 }
//    	 else
//    	 {
//    		 msg.prompt="存储空间不足，文件包无法解压缩！";
//    		 msg.msg=("当前存储位置:"+rootpath+
//    				 "\n目前剩余空间:"+(t_len/(1024*1024)+1)+"M"+
//				      "\n解压需要空间:"+(len/(1024*1024)+1)+"M"+
//				      "\n请前往 \'"+MSharedPreferences.getTextbookManagerPageName(context)+"\' 处"+
//	                  "\n清理无用或过期的文件，以便有足够可用的空间");
//    		 msg.bArg=false;
//    		 return msg;
//    	 }
//     }
//     public static long getRarFileUnpackSize(File archive)
//     {
//     	long filelen=0;
//     	Archive arch = null;
// 	    try {
// 	      arch = new Archive(archive);
// 	    } catch (RarException e)
// 	    {
//
// 	    } catch (IOException e1)
// 	    {
//
// 	    }
// 	    if (arch != null)
// 	    {
// 	       if (arch.isEncrypted())
// 	       {
// 	    	  try {
// 					arch.close();
// 				} catch (IOException e) {
// 					// TODO 自动生成的 catch 块
// 					e.printStackTrace();
// 				}
// 	 	       arch=null;
// 	    	   return filelen;
// 	       }
// 	       FileHeader fh = null;
// 	       while (true)
// 	       {
// 		      fh = arch.nextFileHeader();
// 		      if (fh == null) {
// 		        break;
// 		      }
// 		      if (fh.isEncrypted()) {
// 		         continue;
// 		      }
// 		      if (fh.isDirectory()) {
// 			 } else {
// 				 filelen+=fh.getFullUnpackSize();
// 			 }
// 	       }
// 	    }
// 	    if(arch != null)
//			try {
//				arch.close();
//			} catch (IOException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			}
// 	    arch=null;
// 	    return filelen;
//     }
//     public static long getZipFileUnpackSize(String zipPath) throws FileNotFoundException, ZipException, IOException
//     {
//     	long filelen=0;
//     	String encoding=null;
//     	// 获取解缩文件
//         File file = new File(zipPath);
//         if (!file.isFile()) {
//             throw new FileNotFoundException("要解压的文件不存在");
//         }
//         // 设置解压编码
//         if (encoding == null || "".equals(encoding)) {
//             encoding = "GBK";
//         }
//         // 实例化ZipFile对象
//         ZipFile zipFile = null;
//         try{
//         	zipFile = new ZipFile(file, encoding);
//         }catch(Exception e){
//         	zipFile = new ZipFile(file, encoding);
//         }
//
//         // 获取ZipFile中的条目
//         Enumeration<ZipEntry> files = zipFile.getEntries();
//         // 迭代中的每一个条目
//         ZipEntry entry = null;
//
//         while (files.hasMoreElements())
//         {
//             // 获取解压条目
//             entry = files.nextElement();
//             // 如果条目为目录，则跳向下一个
//             if (entry.getName().endsWith(File.separator)) {
//                 continue;
//             }
//             filelen+=entry.getSize();
//         }
//         zipFile.close();
//         zipFile=null;
//         return filelen;
//     }

/* 打印信息
E/获取当前程序路径:: /data/data/android.ltd.simulator/files
E/获取程序默认数据库路径:: /data/data/android.ltd.simulator/databases/s
E/获取该程序的安装包路径:: /data/app/android.ltd.simulator-2.apk
E/sd卡路径:: /storage/emulated/0   */
	/**
	 *  获取当前程序路径
	 * @param context
	 * @return /data/data/android.ltd.simulator/files
	 */
	public static String getAbsolutePath(Context context){
		return context.getApplicationContext().getFilesDir().getAbsolutePath();
	}

	/**
	 * 获取该程序的安装包路径
	 * @param context
	 * @return
	 */
	public static String getPackageResourcePath(Context context){
		return context.getApplicationContext().getPackageResourcePath();
	}
	/**
	 * 获取程序默认数据库路径
	 * @param context
	 * @return
	 */
	public static String getDataBasePath(Context context){
		return context.getApplicationContext().getDatabasePath("s").getAbsolutePath();
	}
	/**
	 * 获取系统默认的download文件夹
	 * @return
	 */
	public static String getDownloadPath(){
		return getExternalStoragePublicDirectory(DIRECTORY_DOWNLOADS).getPath();
	}
	/**
	 * 获取系统默认的Picture文件夹
	 * @return
	 */
	public static String getPicturePath(){
		return getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES).getPath();
//		return getExternalStoragePublicDirectory(DIRECTORY_DOWNLOADS).getPath();
	}



	/********************************************************************************************************/
     /**
      * 获取内置SD卡、外置SD卡路径以及TF卡的路径
      * 返回的数据：paths.get(0)肯定是内置SD卡的位置，因为它是primary external storage.
      *
      * @return 所有可用于存储的不同的卡的位置，用一个List来保存
      */
     public static List<String> getAllSDCardPathList() {
		 List<String> pathsList = new ArrayList<>();
//    	 paths.clear();
         String extFileStatus = Environment.getExternalStorageState();
         File extFile = Environment.getExternalStorageDirectory();
         String innerSdPath = null;
         //首先判断一下内置SD卡的状态，处于挂载状态才能获取的到
         if (extFileStatus.equals(Environment.MEDIA_MOUNTED)
                 && extFile.exists() && extFile.isDirectory()
                 && extFile.canWrite()) {
             //内置SD卡的路径
			 innerSdPath = extFile.getAbsolutePath();
         }
		 pathsList.add(innerSdPath);

		 List<String> extPathList = getExtSDCardPathList(innerSdPath) ;
		 if (CollectionUtil.isNotEmpty(extPathList)){
			 //加入外部扩展SD卡
			 pathsList.addAll(extPathList);
		 }
         return pathsList;
     }

//     public static List<StoragePathInfo> getExtSDCardPathList1(List<StoragePathInfo> paths) {
//    	 paths.clear();
//         String extFileStatus = Environment.getExternalStorageState();
//         File extFile = Environment.getExternalStorageDirectory();
//         String DefaultPath = null;
//         //首先判断一下外置SD卡的状态，处于挂载状态才能获取的到
//         if (extFileStatus.equals(Environment.MEDIA_MOUNTED)
//                 && extFile.exists() && extFile.isDirectory()
//                 && extFile.canWrite()) {
//             //外置SD卡的路径
//        	 DefaultPath = extFile.getAbsolutePath();
//         }
//         paths.add(new StoragePathInfo(DefaultPath,0));
//
//         String[] columns;
//         String PATH = getMyStorageDirectory_new(DefaultPath);
// 		 columns = PATH.split("\n");
// 		 for(int i=0; i<columns.length; i++)
// 		 {
// 			String t_str=columns[i];
// 			if(Define.isEmptyByString(t_str) != null)
// 			{
// 				if(checkRW(t_str))
// 				{
// 					paths.add(new StoragePathInfo(t_str,0));
// 				}else
// 				{
// 					paths.add(new StoragePathInfo(t_str,1));
// 				}
// 			}
//		 }
//         return paths;
//     }
//
     /**
      * 测试外置卡是否可写
      * @param path 存储卡路径
      * @return true 可读写
      */

     private static boolean checkRW(String path) {
		 boolean result = false ;
		 if (StringUtil.isNotEmpty(path)) {
			 String txt = "测试成功.txt";
			 String sPath = path + File.separator + txt;
			 File file = new File(sPath);
			 try {
//				 FileUtils.touch(file);
				 if (!file.exists()) {
					 file.createNewFile();
				 }
				 result = file.delete();
			 } catch (IOException e) {
                 Log.e(TAG,"sd path is not writeable" + e.toString()) ;
//				 LOGGER.error("sd path is not writeable", e);
				 //			 e.printStackTrace();
			 }
		 }
		 return result;
	 }
     /***********************************************************************************************/
}
